import axios from 'axios'
import { Message, MessageBox } from 'element-ui'
import store from '@/store'
import router from '@/router'

// 创建axios实例
const service = axios.create({
//   baseURL: process.env.VUE_APP_BASE_API || '/api', // API的基础URL
  baseURL: 'http://42.192.114.110:6060/smart-plat' || '/api', // API的基础URL
  timeout: 15000 // 请求超时时间
})

// 请求拦截器
service.interceptors.request.use(
  config => {
    // 在发送请求之前做些什么
    // 设置统一的Content-Type
    config.headers['Content-Type'] = 'application/json'
    
    const token = localStorage.getItem('token')
    if (token) {
      // 直接从localStorage获取token
      config.headers['Authorization'] = token.split(".")[0]+' ' + token
    }
    return config
  },
  error => {
    // 对请求错误做些什么
    console.error('Request error:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    const res = response.data
    
    // 如果返回的自定义状态码不是0，则判断为错误
    if (res.code !== 0) {
      // 401: token过期; 50008: 非法的token; 50012: 其他客户端登录; 50014: Token过期了;
      if (res.code === 401 || res.code === 50008 || res.code === 50012 || res.code === 50014) {
        // 直接清除存储并跳转，不显示确认对话框
        localStorage.clear()
        sessionStorage.clear()
        // 调用store的登出方法
        store.dispatch('logout').then(() => {
          // 跳转到登录页面
          router.push('/login')
        })
        return Promise.reject(new Error('登录已过期'))
      } else {
        Message({
          message: res.msg || 'Error',
          type: 'error',
          duration: 5 * 1000
        })
      }
      return Promise.reject(new Error(res.msg || 'Error'))
    } else {
      return res
    }
  },
  error => {
    console.error('Response error:', error)
    
    // 处理HTTP错误状态码
    let message = error.message
    if (error.response) {
      switch (error.response.status) {
        case 401:
          message = '登录已过期，请重新登录'
          // 清除所有本地存储数据
          localStorage.clear()
          sessionStorage.clear()
          // 调用store的登出方法
          store.dispatch('logout').then(() => {
            // 跳转到登录页面
            router.push('/login')
          })
          return Promise.reject(error)
        case 403:
          message = '拒绝访问'
          break
        case 404:
          message = '请求错误，未找到资源'
          break
        case 500:
          message = '服务器内部错误'
          break
        default:
          message = `连接错误${error.response.status}`
      }
    } else {
      message = '网络连接异常，请稍后再试'
    }
    
    Message({
      message: message,
      type: 'error',
      duration: 5 * 1000
    })
    
    return Promise.reject(error)
  }
)

// 统一配置管理
export const CONFIG = {
  // 后台接口基础URL
  BASE_URL: process.env.VUE_APP_BASE_API || '/plat',
  
  // 渠道选项
  CHANNEL_OPTIONS: [
    { label: '任意渠道', value: 0 },
    { label: '渠道1', value: 1 },
    { label: '渠道2', value: 2 },
    { label: '渠道3', value: 3 },
    { label: '渠道4', value: 4 },
    { label: '渠道5', value: 5 }
  ],
  
  // 道具来源选项
  PROP_SOURCE_OPTIONS: [
    { label: '任意', value: 0 },
    { label: '赠送', value: 1 },
    { label: '充值', value: 2 },
    { label: '游戏奖励', value: 3 },
    { label: '签到奖励', value: 4 },
    { label: '救济金', value: 5 }
  ]
}

// 缓存渠道列表
let channelListCache = null
let channelListCacheTime = 0
const CACHE_DURATION = 5 * 60 * 1000 // 5分钟缓存

/**
 * 获取渠道列表
 * 通过统计接口获取所有已有的渠道
 * @returns {Promise<Array>} 渠道选项数组
 */
export async function getChannelList() {
  // 检查缓存
  const now = Date.now()
  if (channelListCache && (now - channelListCacheTime) < CACHE_DURATION) {
    return channelListCache
  }

  try {
    // 通过支付统计接口获取渠道数据
    const response = await service({
      url: '/statistic/pay',
      method: 'post',
      data: {
        page: 1,
        page_size: 1000, // 获取大量数据来收集所有渠道
        channel: 0 // 0表示获取所有渠道
      }
    })

    if (response && response.code === 0) {
      let records = []
      if (response.data && response.data.pays && Array.isArray(response.data.pays)) {
        records = response.data.pays
      } else if (response.data && Array.isArray(response.data)) {
        records = response.data
      } else if (response.data && typeof response.data === 'object') {
        for (let key in response.data) {
          if (Array.isArray(response.data[key])) {
            records = response.data[key]
            break
          }
        }
      }

      // 提取所有唯一的渠道号
      const channelSet = new Set()
      records.forEach(record => {
        if (record.channel !== undefined && record.channel !== null) {
          channelSet.add(parseInt(record.channel))
        }
      })

      // 转换为选项数组并排序
      const channels = Array.from(channelSet).sort((a, b) => a - b)
      const channelOptions = [
        { label: '全部', value: null }
      ]
      
      channels.forEach(channel => {
        channelOptions.push({
          label: channel.toString(),
          value: channel
        })
      })

      // 更新缓存
      channelListCache = channelOptions
      channelListCacheTime = now
      
      return channelOptions
    }
  } catch (error) {
    console.error('获取渠道列表失败:', error)
  }

  // 如果获取失败，返回默认选项
  return [
    { label: '全部', value: null },
    { label: '0', value: 0 },
    { label: '1', value: 1 },
    { label: '2', value: 2 },
    { label: '3', value: 3 },
    { label: '4', value: 4 },
    { label: '5', value: 5 },
    { label: '6', value: 6 },
    { label: '7', value: 7 },
    { label: '8', value: 8 },
    { label: '9', value: 9 },
    { label: '10', value: 10 }
  ]
}

/**
 * 清除渠道列表缓存
 */
export function clearChannelListCache() {
  channelListCache = null
  channelListCacheTime = 0
}

export default service 